package abs.dao;

import abs.domain.Clientes;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.skyway.spring.util.dao.AbstractJpaDao;

import org.springframework.dao.DataAccessException;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

/**
 * DAO to manage Clientes entities.
 * 
 */
@Repository("ClientesDAO")
@Transactional
public class ClientesDAOImpl extends AbstractJpaDao<Clientes> implements
		ClientesDAO {

	/**
	 * Set of entity classes managed by this DAO.  Typically a DAO manages a single entity.
	 *
	 */
	private final static Set<Class<?>> dataTypes = new HashSet<Class<?>>(Arrays.asList(new Class<?>[] { Clientes.class }));

	/**
	 * EntityManager injected by Spring for persistence unit absV2
	 *
	 */
	@PersistenceContext(unitName = "absV2")
	private EntityManager entityManager;

	/**
	 * Instantiates a new ClientesDAOImpl
	 *
	 */
	public ClientesDAOImpl() {
		super();
	}

	/**
	 * Get the entity manager that manages persistence unit 
	 *
	 */
	@Override
	public EntityManager getEntityManager() {
		return entityManager;
	}

	/**
	 * Returns the set of entity classes managed by this DAO.
	 *
	 */
	@Override
	public Set<Class<?>> getTypes() {
		return dataTypes;
	}

	/**
	 * JPQL Query - findClientesByPrimaryKey
	 *
	 */
	@Override
	@Transactional
	public Clientes findClientesByPrimaryKey(String cl100nocia, Integer cl100cocl) throws DataAccessException {

		return findClientesByPrimaryKey(cl100nocia, cl100cocl, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByPrimaryKey
	 *
	 */

	@Override
	@Transactional
	public Clientes findClientesByPrimaryKey(String cl100nocia, Integer cl100cocl, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findClientesByPrimaryKey", startResult, maxRows, cl100nocia, cl100cocl);
			return (abs.domain.Clientes) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findClientesByCl100ctacrContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100ctacrContaining(String cl100ctacr) throws DataAccessException {

		return findClientesByCl100ctacrContaining(cl100ctacr, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100ctacrContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100ctacrContaining(String cl100ctacr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100ctacrContaining", startResult, maxRows, cl100ctacr);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100ctadb
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100ctadb(String cl100ctadb) throws DataAccessException {

		return findClientesByCl100ctadb(cl100ctadb, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100ctadb
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100ctadb(String cl100ctadb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100ctadb", startResult, maxRows, cl100ctadb);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100obse
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100obse(String cl100obse) throws DataAccessException {

		return findClientesByCl100obse(cl100obse, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100obse
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100obse(String cl100obse, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100obse", startResult, maxRows, cl100obse);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100feadAfter
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100feadAfter(java.util.Calendar cl100fead) throws DataAccessException {

		return findClientesByCl100feadAfter(cl100fead, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100feadAfter
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100feadAfter(java.util.Calendar cl100fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100feadAfter", startResult, maxRows, cl100fead);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100femoBefore
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100femoBefore(java.util.Calendar cl100femo) throws DataAccessException {

		return findClientesByCl100femoBefore(cl100femo, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100femoBefore
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100femoBefore(java.util.Calendar cl100femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100femoBefore", startResult, maxRows, cl100femo);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100fact
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100fact(String cl100fact) throws DataAccessException {

		return findClientesByCl100fact(cl100fact, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100fact
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100fact(String cl100fact, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100fact", startResult, maxRows, cl100fact);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findAllClientess
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findAllClientess() throws DataAccessException {

		return findAllClientess(-1, -1);
	}

	/**
	 * JPQL Query - findAllClientess
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findAllClientess(int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findAllClientess", startResult, maxRows);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100releContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100releContaining(String cl100rele) throws DataAccessException {

		return findClientesByCl100releContaining(cl100rele, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100releContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100releContaining(String cl100rele, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100releContaining", startResult, maxRows, cl100rele);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100ciudContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100ciudContaining(String cl100ciud) throws DataAccessException {

		return findClientesByCl100ciudContaining(cl100ciud, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100ciudContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100ciudContaining(String cl100ciud, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100ciudContaining", startResult, maxRows, cl100ciud);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100nocl
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100nocl(String cl100nocl) throws DataAccessException {

		return findClientesByCl100nocl(cl100nocl, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100nocl
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100nocl(String cl100nocl, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100nocl", startResult, maxRows, cl100nocl);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100provContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100provContaining(String cl100prov) throws DataAccessException {

		return findClientesByCl100provContaining(cl100prov, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100provContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100provContaining(String cl100prov, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100provContaining", startResult, maxRows, cl100prov);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100load
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100load(String cl100load) throws DataAccessException {

		return findClientesByCl100load(cl100load, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100load
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100load(String cl100load, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100load", startResult, maxRows, cl100load);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100tifa
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100tifa(String cl100tifa) throws DataAccessException {

		return findClientesByCl100tifa(cl100tifa, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100tifa
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100tifa(String cl100tifa, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100tifa", startResult, maxRows, cl100tifa);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100cgre
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100cgre(Integer cl100cgre) throws DataAccessException {

		return findClientesByCl100cgre(cl100cgre, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100cgre
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100cgre(Integer cl100cgre, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100cgre", startResult, maxRows, cl100cgre);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100lomo
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100lomo(String cl100lomo) throws DataAccessException {

		return findClientesByCl100lomo(cl100lomo, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100lomo
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100lomo(String cl100lomo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100lomo", startResult, maxRows, cl100lomo);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100dscp
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100dscp(java.math.BigDecimal cl100dscp) throws DataAccessException {

		return findClientesByCl100dscp(cl100dscp, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100dscp
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100dscp(java.math.BigDecimal cl100dscp, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100dscp", startResult, maxRows, cl100dscp);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100contContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100contContaining(String cl100cont) throws DataAccessException {

		return findClientesByCl100contContaining(cl100cont, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100contContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100contContaining(String cl100cont, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100contContaining", startResult, maxRows, cl100cont);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100rele
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100rele(String cl100rele) throws DataAccessException {

		return findClientesByCl100rele(cl100rele, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100rele
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100rele(String cl100rele, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100rele", startResult, maxRows, cl100rele);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100factContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100factContaining(String cl100fact) throws DataAccessException {

		return findClientesByCl100factContaining(cl100fact, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100factContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100factContaining(String cl100fact, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100factContaining", startResult, maxRows, cl100fact);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByPrimaryKey
	 *
	 */
	@Transactional
	public Clientes findClientesByPrimaryKey(Integer cl100cocl) throws DataAccessException {

		return findClientesByPrimaryKey(cl100cocl, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByPrimaryKey
	 *
	 */

	@Transactional
	public Clientes findClientesByPrimaryKey(Integer cl100cocl, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findClientesByPrimaryKey", startResult, maxRows, cl100cocl);
			return (abs.domain.Clientes) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findClientesByCl100tar1Containing
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100tar1Containing(String cl100tar1) throws DataAccessException {

		return findClientesByCl100tar1Containing(cl100tar1, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100tar1Containing
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100tar1Containing(String cl100tar1, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100tar1Containing", startResult, maxRows, cl100tar1);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100prov
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100prov(String cl100prov) throws DataAccessException {

		return findClientesByCl100prov(cl100prov, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100prov
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100prov(String cl100prov, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100prov", startResult, maxRows, cl100prov);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100tifaContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100tifaContaining(String cl100tifa) throws DataAccessException {

		return findClientesByCl100tifaContaining(cl100tifa, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100tifaContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100tifaContaining(String cl100tifa, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100tifaContaining", startResult, maxRows, cl100tifa);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100tar2
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100tar2(String cl100tar2) throws DataAccessException {

		return findClientesByCl100tar2(cl100tar2, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100tar2
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100tar2(String cl100tar2, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100tar2", startResult, maxRows, cl100tar2);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100tar2Containing
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100tar2Containing(String cl100tar2) throws DataAccessException {

		return findClientesByCl100tar2Containing(cl100tar2, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100tar2Containing
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100tar2Containing(String cl100tar2, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100tar2Containing", startResult, maxRows, cl100tar2);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100diofContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100diofContaining(String cl100diof) throws DataAccessException {

		return findClientesByCl100diofContaining(cl100diof, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100diofContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100diofContaining(String cl100diof, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100diofContaining", startResult, maxRows, cl100diof);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100fead
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100fead(java.util.Calendar cl100fead) throws DataAccessException {

		return findClientesByCl100fead(cl100fead, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100fead
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100fead(java.util.Calendar cl100fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100fead", startResult, maxRows, cl100fead);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100cupo
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100cupo(java.math.BigDecimal cl100cupo) throws DataAccessException {

		return findClientesByCl100cupo(cl100cupo, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100cupo
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100cupo(java.math.BigDecimal cl100cupo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100cupo", startResult, maxRows, cl100cupo);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100fadeContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100fadeContaining(String cl100fade) throws DataAccessException {

		return findClientesByCl100fadeContaining(cl100fade, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100fadeContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100fadeContaining(String cl100fade, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100fadeContaining", startResult, maxRows, cl100fade);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100loadContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100loadContaining(String cl100load) throws DataAccessException {

		return findClientesByCl100loadContaining(cl100load, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100loadContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100loadContaining(String cl100load, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100loadContaining", startResult, maxRows, cl100load);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100femoAfter
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100femoAfter(java.util.Calendar cl100femo) throws DataAccessException {

		return findClientesByCl100femoAfter(cl100femo, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100femoAfter
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100femoAfter(java.util.Calendar cl100femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100femoAfter", startResult, maxRows, cl100femo);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100ctadbContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100ctadbContaining(String cl100ctadb) throws DataAccessException {

		return findClientesByCl100ctadbContaining(cl100ctadb, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100ctadbContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100ctadbContaining(String cl100ctadb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100ctadbContaining", startResult, maxRows, cl100ctadb);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100feadBefore
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100feadBefore(java.util.Calendar cl100fead) throws DataAccessException {

		return findClientesByCl100feadBefore(cl100fead, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100feadBefore
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100feadBefore(java.util.Calendar cl100fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100feadBefore", startResult, maxRows, cl100fead);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100teo1Containing
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100teo1Containing(String cl100teo1) throws DataAccessException {

		return findClientesByCl100teo1Containing(cl100teo1, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100teo1Containing
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100teo1Containing(String cl100teo1, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100teo1Containing", startResult, maxRows, cl100teo1);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100cont
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100cont(String cl100cont) throws DataAccessException {

		return findClientesByCl100cont(cl100cont, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100cont
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100cont(String cl100cont, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100cont", startResult, maxRows, cl100cont);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100cocl
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100cocl(Integer cl100cocl) throws DataAccessException {

		return findClientesByCl100cocl(cl100cocl, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100cocl
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100cocl(Integer cl100cocl, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100cocl", startResult, maxRows, cl100cocl);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100ciud
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100ciud(String cl100ciud) throws DataAccessException {

		return findClientesByCl100ciud(cl100ciud, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100ciud
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100ciud(String cl100ciud, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100ciud", startResult, maxRows, cl100ciud);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100fade
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100fade(String cl100fade) throws DataAccessException {

		return findClientesByCl100fade(cl100fade, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100fade
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100fade(String cl100fade, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100fade", startResult, maxRows, cl100fade);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100diof
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100diof(String cl100diof) throws DataAccessException {

		return findClientesByCl100diof(cl100diof, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100diof
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100diof(String cl100diof, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100diof", startResult, maxRows, cl100diof);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100nociaContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100nociaContaining(String cl100nocia) throws DataAccessException {

		return findClientesByCl100nociaContaining(cl100nocia, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100nociaContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100nociaContaining(String cl100nocia, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100nociaContaining", startResult, maxRows, cl100nocia);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100noclContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100noclContaining(String cl100nocl) throws DataAccessException {

		return findClientesByCl100noclContaining(cl100nocl, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100noclContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100noclContaining(String cl100nocl, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100noclContaining", startResult, maxRows, cl100nocl);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100emaiContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100emaiContaining(String cl100emai) throws DataAccessException {

		return findClientesByCl100emaiContaining(cl100emai, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100emaiContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100emaiContaining(String cl100emai, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100emaiContaining", startResult, maxRows, cl100emai);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100emai
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100emai(String cl100emai) throws DataAccessException {

		return findClientesByCl100emai(cl100emai, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100emai
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100emai(String cl100emai, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100emai", startResult, maxRows, cl100emai);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100teo1
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100teo1(String cl100teo1) throws DataAccessException {

		return findClientesByCl100teo1(cl100teo1, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100teo1
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100teo1(String cl100teo1, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100teo1", startResult, maxRows, cl100teo1);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100femo
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100femo(java.util.Calendar cl100femo) throws DataAccessException {

		return findClientesByCl100femo(cl100femo, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100femo
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100femo(java.util.Calendar cl100femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100femo", startResult, maxRows, cl100femo);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100ceduContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100ceduContaining(String cl100cedu) throws DataAccessException {

		return findClientesByCl100ceduContaining(cl100cedu, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100ceduContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100ceduContaining(String cl100cedu, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100ceduContaining", startResult, maxRows, cl100cedu);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100cedu
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100cedu(String cl100cedu) throws DataAccessException {

		return findClientesByCl100cedu(cl100cedu, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100cedu
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100cedu(String cl100cedu, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100cedu", startResult, maxRows, cl100cedu);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100lomoContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100lomoContaining(String cl100lomo) throws DataAccessException {

		return findClientesByCl100lomoContaining(cl100lomo, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100lomoContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100lomoContaining(String cl100lomo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100lomoContaining", startResult, maxRows, cl100lomo);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100obseContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100obseContaining(String cl100obse) throws DataAccessException {

		return findClientesByCl100obseContaining(cl100obse, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100obseContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100obseContaining(String cl100obse, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100obseContaining", startResult, maxRows, cl100obse);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100nocia
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100nocia(String cl100nocia) throws DataAccessException {

		return findClientesByCl100nocia(cl100nocia, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100nocia
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100nocia(String cl100nocia, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100nocia", startResult, maxRows, cl100nocia);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100ctacr
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100ctacr(String cl100ctacr) throws DataAccessException {

		return findClientesByCl100ctacr(cl100ctacr, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100ctacr
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100ctacr(String cl100ctacr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100ctacr", startResult, maxRows, cl100ctacr);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * JPQL Query - findClientesByCl100tar1
	 *
	 */
	@Override
	@Transactional
	public Set<Clientes> findClientesByCl100tar1(String cl100tar1) throws DataAccessException {

		return findClientesByCl100tar1(cl100tar1, -1, -1);
	}

	/**
	 * JPQL Query - findClientesByCl100tar1
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Clientes> findClientesByCl100tar1(String cl100tar1, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findClientesByCl100tar1", startResult, maxRows, cl100tar1);
		return new LinkedHashSet<Clientes>(query.getResultList());
	}

	/**
	 * Used to determine whether or not to merge the entity or persist the entity when calling Store
	 * @see store
	 * 
	 *
	 */
	@Override
	public boolean canBeMerged(Clientes entity) {
		return true;
	}
}
